home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Programming / MUI / MCC_Listtree / developer / autodocs / MCC_Listtree.doc
Encoding:
Text File  |  1998-05-22  |  27.1 KB  |  1,043 lines
  1. TABLE OF CONTENTS
  2.  
  3. Listtree.mcc/Listtree.mcc
  4. Listtree.mcc/MUIA_Listtree_Active
  5. Listtree.mcc/MUIA_Listtree_CloseHook
  6. Listtree.mcc/MUIA_Listtree_ConstructHook
  7. Listtree.mcc/MUIA_Listtree_DestructHook
  8. Listtree.mcc/MUIA_Listtree_DisplayHook
  9. Listtree.mcc/MUIA_Listtree_DoubleClick
  10. Listtree.mcc/MUIA_Listtree_DragDropSort
  11. Listtree.mcc/MUIA_Listtree_DuplicateNodeName
  12. Listtree.mcc/MUIA_Listtree_EmptyNodes
  13. Listtree.mcc/MUIA_Listtree_Format
  14. Listtree.mcc/MUIA_Listtree_OpenHook
  15. Listtree.mcc/MUIA_Listtree_Quiet
  16. Listtree.mcc/MUIA_Listtree_SortHook
  17. Listtree.mcc/MUIA_Listtree_Title
  18. Listtree.mcc/MUIA_Listtree_TreeColumn
  19. Listtree.mcc/MUIM_Listtree_Close
  20. Listtree.mcc/MUIM_Listtree_Exchange
  21. Listtree.mcc/MUIM_Listtree_FindName
  22. Listtree.mcc/MUIM_Listtree_GetEntry
  23. Listtree.mcc/MUIM_Listtree_GetNr
  24. Listtree.mcc/MUIM_Listtree_Insert
  25. Listtree.mcc/MUIM_Listtree_Move
  26. Listtree.mcc/MUIM_Listtree_Open
  27. Listtree.mcc/MUIM_Listtree_Remove
  28. Listtree.mcc/MUIM_Listtree_Rename
  29. Listtree.mcc/MUIM_Listtree_SetDropMark
  30. Listtree.mcc/MUIM_Listtree_Sort
  31. Listtree.mcc/MUIM_Listtree_TestPos
  32.  
  33. Listtree.mcc/Listtree.mcc
  34.  
  35.     This listtree class handles tree nodes, which can be defined as node
  36.     or as leaf. Only nodes contain a list where other tree nodes can be
  37.     inserted.
  38.     
  39.     Every tree node contains a name, flags and a pointer to user data,
  40.     this is handled by the MUIS_Listtree_TreeNode struct.
  41.     
  42.     ********************************************************************
  43.          This struct is read-only, never change it by your own !!!
  44.     ********************************************************************
  45.     
  46.     You can create a very complex tree. There exist two different lists
  47.     of tree nodes, first the one which contains all the tree nodes you
  48.     have inserted. All modifications are made to this list. The second
  49.     list is the display list, which is shown as ListObject. As you can
  50.     open or close a node, not all of the existing tree nodes are
  51.     displayed.
  52.     
  53.     Tree nodes contain a flag bitfield:
  54.     
  55.       TNF_LIST    The node contains a list where other nodes can be
  56.                   inserted.
  57.       TNF_OPEN    The list node is open, sub nodes are displayed.
  58.       TNF_FROZEN  The node doesn't react on doubleclick or open/close by
  59.                   user.
  60.       TNF_NOSIGN  The indicator of list nodes isn't shown.
  61.     
  62.     The tree nodes can be inserted and removed, sorted, moved, exchanged
  63.     or renamed. To sort you can also drag&drop them. Modifications can be
  64.     made in relation to the whole tree, to one level, to a sub-tree or to
  65.     only one tree node, the visibility is checked or not.
  66.     
  67.     The user can control the listtree by the MUI keys, this means a node
  68.     is opened with "Right" and closed with "Left". Check your MUI
  69.     preferences for the specified keys.
  70.     
  71.     You can define which of the columns will react on double-clicking. The
  72.     node toggles its status: opened or closed.
  73.     
  74.     Only one entry can be selected yet, so you can't use the listtree for
  75.     multi selecting.
  76.     
  77.     Drag&Drop capabilities:
  78.     If you set MUIA_Listview_DragType of the parent listview to 1, the
  79.     list tree will become active for Drag&Drop. This means you can only
  80.     drag one entry and will drop it on the same listtree again. While
  81.     dragging an indicator shows where to drop.
  82.     
  83.       Drag a   Drop on       Result
  84.     
  85.       Leaf     Leaf          Exchange leaves.
  86.       Node     Leaf          Nothing happens.
  87.       Entry    Closed Node   Move entry, MUIA_Listtree_SortHook is used.
  88.       Entry    Open Node     Move entry to defined position.
  89.     
  90.     You cannot drop an entry on itself, nor you can drop an opened node on
  91.     any of its members.
  92.     
  93.     To interchange data with other object you have to create your own
  94.     subclass of Listtree.mcc and react on the drag methods.
  95.  
  96. Listtree.mcc/MUIA_Listtree_Active
  97.  
  98.    NAME
  99.     MUIA_Listtree_Active -- [.SG], struct TreeNode *
  100.  
  101.    SPECIAL VALUES
  102.     MUIA_Listtree_Active_Off
  103.  
  104.    FUNCTION
  105.     Setting this attribute will move the cursor on the defined tree node,
  106.     if it is visible. If the node is in an opened tree the listview is
  107.     scrolling into the visible area. Setting MUIV_Listtree_Actice_Off will
  108.     vanish the cursor.
  109.     
  110.     If this attribute is read it returns the active tree node. The result
  111.     is MUIV_Listtree_Actice_Off if there is no active entry.
  112.  
  113.    NOTIFICATIONS
  114.     Now you can create a notification on MUIA_Listtree_Active. The
  115.     TriggerValue is the active tree node.
  116.  
  117.    SEE ALSO
  118.     MUIA_List_First, MUIA_List_Visible
  119.  
  120. Listtree.mcc/MUIA_Listtree_CloseHook
  121.  
  122.    NAME
  123.     MUIA_Listtree_CloseHook -- [IS.], struct Hook *
  124.  
  125.    FUNCTION
  126.     The close hook is called after a list node is closed, then you can
  127.     change the list.
  128.     
  129.     The close hook will be called with the hook in A0, the tree node in
  130.     register A1.
  131.     
  132.     To remove the hook set this to NULL.
  133.  
  134.    SEE ALSO
  135.     MUIA_Listtree_Open, MUIA_Listtree_CloseHook
  136.  
  137. Listtree.mcc/MUIA_Listtree_ConstructHook
  138.  
  139.    NAME
  140.     MUIA_Listtree_ConstructHook -- [IS.], struct Hook *
  141.  
  142.    SPECIAL VALUES
  143.     MUIV_Listtree_ConstructHook_String
  144.  
  145.    FUNCTION
  146.     The construct hook is called whenever you add an entry to your
  147.     listtree. The pointer isn't inserted directly, the construct hook is
  148.     called and its result code is added.
  149.     
  150.     When an entry shall be removed the corresponding destruct hook is
  151.     called.
  152.     
  153.     The construct hook will be called with the hook in A0, the data given
  154.     to MUIM_Listtree_Insert as message in register A1 and with pointer to
  155.     a standard kick 3.x memory pool in A2. If you want, you can use the
  156.     exec or amiga.lib functions for allocating memory within this pool,
  157.     but this is only an option.
  158.     
  159.     If the construct hook returns NULL, nothing will be added to the list.
  160.     
  161.     There is a builtin construct hook available called
  162.     MUIV_Listtree_ConstructHook_String. This expects that the 'User' data
  163.     in the treenode is a string, which is copied. Of course you have to
  164.     use MUIV_Listtree_DestructHook_String in this case!
  165.  
  166.    SEE ALSO
  167.     MUIA_List_ConstructHook, MUIA_Listtree_DestructHook,
  168.     MUIA_Listtree_DisplayHook
  169.  
  170. Listtree.mcc/MUIA_Listtree_DestructHook
  171.  
  172.    NAME
  173.     MUIA_Listtree_DestructHook -- [IS.], struct Hook *
  174.  
  175.    SPECIAL VALUES
  176.     MUIV_Listtree_DestructHook_String
  177.  
  178.    FUNCTION
  179.     Set up a destruct hook for your listtree. For more info see
  180.     MUIA_Listtree_ConstructHook.
  181.  
  182.    SEE ALSO
  183.     MUIA_List_ConstructHook, MUIA_Listtree_ConstructHook,
  184.     MUIA_Listtree_DisplayHook
  185.  
  186. Listtree.mcc/MUIA_Listtree_DisplayHook
  187.  
  188.    NAME
  189.     MUIA_Listtree_DisplayHook -- [IS.], struct Hook *
  190.  
  191.    FUNCTION
  192.     You have to supply a display hook to specify what should be shown in
  193.     the listview, otherwise only the name of the nodes is displayed.
  194.     
  195.     The hook will be called with a pointer to the tree node to be
  196.     displayed in A1 and a pointer to a string array containing as many
  197.     entries as your listtree may have columns in A2.
  198.     
  199.     You have to fill this array with the strings you want to display.
  200.     Check out that the array pointer of the tree column isn't used or set
  201.     to NULL, if the normal name of the node should appear.
  202.     
  203.     You can set the array pointer of the tree column to a string, which is
  204.     diplayed instead of the node name. You can use this to mark nodes.
  205.     
  206.     See MUIA_List_Format for details about column handling.
  207.  
  208.    SEE ALSO
  209.     MUIA_List_Format, MUIA_Text_Contents
  210.  
  211. Listtree.mcc/MUIA_Listtree_DoubleClick
  212.  
  213.    NAME
  214.     MUIA_Listtree_DoubleClick -- [ISG], ULONG
  215.  
  216.    SPECIAL VALUES
  217.     MUIA_Listtree_DoubleClick_Off
  218.     MUIA_Listtree_DoubleClick_All
  219.     MUIA_Listtree_DoubleClick_Tree
  220.  
  221.    FUNCTION
  222.     A doubleclick opens a node if it was closed, it is closed if the node
  223.     was open. You have to set the column which should do this.
  224.     
  225.     Normally only the column number is set here, but there are special
  226.     values:
  227.     
  228.     MUIV_Listtree_DoubleClick_Off:
  229.       A doubleclick is not handled.
  230.     
  231.     MUIV_Listtree_DoubleClick_All:
  232.       All columns reacts on a doubleclick.
  233.     
  234.     MUIV_Listtree_DoubleClick_Tree
  235.       Only a doubleclick on the defined tree column is recognized.
  236.  
  237.    NOTIFICATIONS
  238.     The TriggerValue of the notification is the tree node you have
  239.     doubleclicked, you can get() MUIA_Listtree_DoubleClick for the column
  240.     number. The struct 'MUIS_Listtree_TreeNode' is used for trigger.
  241.     
  242.     The notification is done on leaves and on node columns, which are not
  243.     set in MUIA_Listtree_DoubleClick.
  244.  
  245. Listtree.mcc/MUIA_Listtree_DragDropSort
  246.  
  247.    NAME
  248.     MUIA_Listtree_DragDropSort -- [IS.], BOOL
  249.  
  250.    FUNCTION
  251.     Setting this attribute to TRUE will disable the ability to sort the
  252.     list tree by drag&drop.
  253.  
  254. Listtree.mcc/MUIA_Listtree_DuplicateNodeName
  255.  
  256.    NAME
  257.     MUIA_Listtree_DuplicateNodeName -- [IS.], BOOL
  258.  
  259.    FUNCTION
  260.     If this attribute is set to FALSE the names of the node will not be
  261.     duplicated, only the string pointers are used. Be careful the string
  262.     have to be valid everytime.
  263.  
  264. Listtree.mcc/MUIA_Listtree_EmptyNodes
  265.  
  266.    NAME
  267.     MUIA_Listtree_EmptyNodes -- [IS.], BOOL
  268.  
  269.    FUNCTION
  270.     Setting this attribute to TRUE will display all empty nodes as leaves,
  271.     this means no list indicator is shown. Nevertheless the entry is
  272.     handled like a node.
  273.  
  274. Listtree.mcc/MUIA_Listtree_Format
  275.  
  276.    NAME
  277.     MUIA_Listtree_Format -- [IS.], STRPTR
  278.  
  279.    FUNCTION
  280.     Same as MUIA_List_Format, but one column is reserved for the tree
  281.     indicators and the names of the nodes.
  282.     
  283.     For further detailed information see MUIA_List_Format!
  284.  
  285.    SEE ALSO
  286.     MUIA_List_Format, MUIA_Listtree_DisplayHook, MUIA_Text_Contents
  287.  
  288. Listtree.mcc/MUIA_Listtree_OpenHook
  289.  
  290.    NAME
  291.     MUIA_Listtree_OpenHook -- [IS.], struct Hook *
  292.  
  293.    FUNCTION
  294.     The open hook is called whenever a list node will be opened, so you
  295.     can change the list before the node is open.
  296.     
  297.     The open hook will be called with the hook in A0, the tree node in
  298.     register A1.
  299.     
  300.     To remove the hook set this to NULL.
  301.  
  302.    SEE ALSO
  303.     MUIA_Listtree_Open, MUIA_Listtree_CloseHook
  304.  
  305. Listtree.mcc/MUIA_Listtree_Quiet
  306.  
  307.    NAME
  308.     MUIA_Listtree_Quiet -- [.S.], BOOL
  309.  
  310.    FUNCTION
  311.     If you add/remove lots of entries to/from a listtree, this will cause
  312.     lots of screen action and slow down the operation. Setting
  313.     MUIA_Listtree_Quiet to TRUE will temporarily prevent the listtree from
  314.     being refreshed, this refresh will take place only once when you set
  315.     it back to FALSE again.
  316.     
  317.     Do not use MUIA_List_Quiet here!
  318.  
  319.    SEE ALSO
  320.     MUIM_Listtree_Insert, MUIM_Listtree_Remove
  321.  
  322. Listtree.mcc/MUIA_Listtree_SortHook
  323.  
  324.    NAME
  325.     MUIA_Listtree_SortHook -- [IS.], struct Hook *
  326.  
  327.    SPECIAL VALUES
  328.     MUIV_Listtree_SortHook_Head
  329.     MUIV_Listtree_SortHook_Tail
  330.     MUIV_Listtree_SortHook_LeavesTop
  331.     MUIV_Listtree_SortHook_LeavesMixed
  332.     MUIV_Listtree_SortHook_LeavesBottom
  333.  
  334.    FUNCTION
  335.     Set this attribute to your own hook if you want to sort the entries in
  336.     the list tree by your own way.
  337.     
  338.     When you are using the insert method with MUIV_Listtree_Insert_Sort or
  339.     dropping an entry on a closed node, this sort hook is called.
  340.     
  341.     There are some builtin sort hooks available, called:
  342.     
  343.     MUIV_Listtree_SortHook_Head
  344.       Any entry is inserted at head of the list.
  345.     
  346.     MUIV_Listtree_SortHook_Tail
  347.       Any entry is inserted at tail of the list.
  348.     
  349.     MUIV_Listtree_SortHook_LeavesTop
  350.       Leaves are inserted at top of the list, nodes at bottom. They are
  351.       alphabetically sorted.
  352.     
  353.     MUIV_Listtree_SortHook_LeavesMixed
  354.       The entries are only alphabetically sorted.
  355.     
  356.     MUIV_Listtree_SortHook_LeavesBottom
  357.       Leaves are inserted at bottom of the list, nodes at top. They are
  358.       alphabetically sorted. This is default.
  359.     
  360.     The hook will be called with one list tree element in A1 and another
  361.     one in A2. You should return something like:
  362.     
  363.         <0   e1 <  e2
  364.          0   e1 == e2
  365.         >0   e1 >  e2
  366.  
  367.    SEE ALSO
  368.     MUIA_Listtree_Insert, MUIM_DragDrop, MUIA_List_CompareHook
  369.  
  370. Listtree.mcc/MUIA_Listtree_Title
  371.  
  372.    NAME
  373.     MUIA_Listtree_Title -- [IS.], char *
  374.  
  375.    FUNCTION
  376.     Specify a title for the current listtree. 
  377.     
  378.     For detailed information see MUIA_List_Title!
  379.  
  380.    BUGS
  381.     The title should not be a string as for single column listviews. This
  382.     attribute can only be set to TRUE or FALSE.
  383.  
  384.    SEE ALSO
  385.     MUIA_List_Title, MUIA_Listtree_DisplayHook
  386.  
  387. Listtree.mcc/MUIA_Listtree_TreeColumn
  388.  
  389.    NAME
  390.     MUIA_Listtree_TreeColumn -- [IS.], ULONG
  391.  
  392.    FUNCTION
  393.     Specify the column of the list tree, the node indicator and the name
  394.     of the node are displayed in.
  395.  
  396.    SEE ALSO
  397.     MUIA_Listtree_DisplayHook, MUIA_Listtree_Format
  398.  
  399. Listtree.mcc/MUIM_Listtree_Close
  400.  
  401.    NAME
  402.     MUIM_Listtree_Close
  403.  
  404.    SYNOPSIS
  405.     DoMethod(obj, MUIM_Listtree_Close,
  406.       APTR ListNode, APTR TreeNode, ULONG Flags);
  407.  
  408.    FUNCTION
  409.     Closes a node or nodes of a listtree, it is checked if the tree node
  410.     is a node, not a leaf!
  411.     
  412.     When the active entry was a child of the closed node, the closed node
  413.     will become active.
  414.  
  415.    INPUTS
  416.     ListNode:
  417.         Specify the node which list is used to find the entry. The search is
  418.         started at the head of the list.
  419.     
  420.         Special values:
  421.     
  422.         MUIV_Listtree_Close_ListNode_Root:
  423.           The root list.
  424.     
  425.         MUIV_Listtree_Close_ListNode_Parent:
  426.           ??? (n/a)
  427.     
  428.         MUIV_Listtree_Close_ListNode_Active:
  429.           The list of the active node. (n/a)
  430.     
  431.     TreeNode:
  432.         The node which is closed. If there are children of the node, they
  433.         are removed from the display list.
  434.     
  435.         Special values:
  436.     
  437.         MUIV_Listtree_Close_TreeNode_Head
  438.           The head of the list, defined in 'ListNode', is closed.
  439.     
  440.         MUIV_Listtree_Close_TreeNode_Tail:
  441.           Closes the tail of the list.
  442.     
  443.         MUIV_Listtree_Close_TreeNode_Active:
  444.           Closes the active node.
  445.     
  446.         MUIV_Listtree_Close_TreeNode_All:
  447.           All nodes of the list, which is specified in 'ListNode', are
  448.           closed.
  449.     
  450.     Flags:
  451.         Specifies the data in 'TreeNode'. Normally this is a pointer to a
  452.         tree node, but the flags can change this into an ULONG.
  453.     
  454.         MUIV_Listtree_Close_Flags_Nr:
  455.           Position (ULONG number) of the node in the list of 'ListNode'.
  456.     
  457.         MUIV_Listtree_Close_Flags_Visible:
  458.           The position is counted on visible entries only.
  459.  
  460.    BUGS
  461.     Not implemented yet:
  462.       MUIV_Listtree_Close_ListNode_Active
  463.       MUIV_Listtree_Close_ListNode_Parent
  464.       MUIV_Listtree_Close_Flags_Nr
  465.       MUIV_Listtree_Close_Flags_Visible
  466.  
  467.    SEE ALSO
  468.     MUIM_Listtree_Open
  469.  
  470. Listtree.mcc/MUIM_Listtree_Exchange
  471.  
  472.    NAME
  473.     MUIM_Listtree_Exchange
  474.  
  475.    SYNOPSIS
  476.     DoMethod(obj, MUIM_Listtree_Exchange,
  477.       APTR TreeNode, APTR TreeNode2, ULONG Flags);
  478.  
  479.    FUNCTION
  480.     Exchanges the two tree entries TreeNode and TreeNode2.
  481.  
  482.    INPUTS
  483.     TreeNode:
  484.         Specify the node which is exchanged.
  485.     
  486.     TreeNode2:
  487.         Specify the other one.
  488.     
  489.     Flags:
  490.  
  491.    BUGS
  492.     Not implemented yet:
  493.     MUIV_Listtree_Exchange_TreeNode2_Up
  494.     MUIV_Listtree_Exchange_TreeNode2_Down
  495.  
  496.    SEE ALSO
  497.     MUIM_Listtree_Move, MUIM_Listtree_Insert, MUIM_Listtree_Remove
  498.  
  499. Listtree.mcc/MUIM_Listtree_FindName
  500.  
  501.    NAME
  502.     MUIM_Listtree_FindName
  503.  
  504.    SYNOPSIS
  505.     APTR TreeNode = DoMethod(obj, MUIM_Listtree_FindName,
  506.       APTR ListNode, char *Name, ULONG Flags);
  507.  
  508.    FUNCTION
  509.     Find a node which name matches the specified one.
  510.  
  511.    INPUTS
  512.     ListNode:
  513.         Specify the node which list is used to find the name.
  514.     
  515.         Special values:
  516.     
  517.         MUIV_Listtree_FindName_ListNode_Root:
  518.           The root list.
  519.     
  520.         MUIV_Listtree_FindName_ListNode_Active:
  521.           The list of the active node.
  522.     
  523.     Flags:
  524.         MUIV_Listtree_FindName_SameLevel:
  525.           Only nodes on the same level are affected.
  526.     
  527.         MUIV_Listtree_FindName_Flags_Visible:
  528.           Only on visible entries is looked at.
  529.  
  530.    SEE ALSO
  531.     MUIM_Listtree_GetEntry
  532.  
  533. Listtree.mcc/MUIM_Listtree_GetEntry
  534.  
  535.    NAME
  536.     MUIM_Listtree_GetEntry
  537.  
  538.    SYNOPSIS
  539.     APTR TreeNode tn = DoMethod(obj, MUIM_Listtree_GetEntry,
  540.       APTR Node, LONG Position, ULONG Flags);
  541.  
  542.    FUNCTION
  543.     Get another node in relation to the specified list or node.
  544.  
  545.    INPUTS
  546.     Node:
  547.         Define the node which is used to find another one. This can also
  548.         be a list node, if the position a related to a list.
  549.     
  550.         Special values:
  551.     
  552.         MUIV_Listtree_GetEntry_ListNode_Root
  553.           The root list is used.
  554.     
  555.         MUIV_Listtree_GetEntry_ListNode_Active:
  556.           The list with the active entry is used.
  557.     
  558.     Position:
  559.         The number of nodes of the list 'Node'.
  560.     
  561.         Special values:
  562.     
  563.         MUIV_Listtree_GetEntry_Position_Head
  564.           The head of the list, see 'Node', is returned.
  565.     
  566.         MUIV_Listtree_GetEntry_Position_Tail
  567.           The tail of the list is returned.
  568.     
  569.         MUIV_Listtree_GetEntry_Position_Active
  570.           The active node is returned, it is NULL if there isn't an active
  571.           entry.
  572.     
  573.         MUIV_Listtree_GetEntry_Position_Next
  574.           The next node after the tree node 'Node' is returned. NULL if it
  575.           isn't available.
  576.     
  577.         MUIV_Listtree_GetEntry_Position_Previous
  578.           The node before the tree node 'Node', Null is returned if 'Node'
  579.           is the head of the list.
  580.     
  581.         MUIV_Listtree_GetEntry_Position_Parent
  582.           The list node of the 'Node', it's the parent one.
  583.     
  584.     Flags:
  585.         MUIV_Listtree_GetEntry_SameLevel:
  586.           Only nodes on the same level are affected.
  587.     
  588.         MUIV_Listtree_GetEntry_Flags_Visible:
  589.           The position is counted on visible entries only.
  590.  
  591.    SEE ALSO
  592.     MUIM_List_GetEntry
  593.  
  594. Listtree.mcc/MUIM_Listtree_GetNr
  595.  
  596.    NAME
  597.     MUIM_Listtree_GetNr
  598.  
  599.    SYNOPSIS
  600.     ULONG Nr = DoMethod(obj, MUIM_Listtree_GetNr,
  601.       APTR TreeNode, ULONG Flags);
  602.  
  603.    FUNCTION
  604.     Get the position of a tree node.
  605.     
  606.     Special values:
  607.     
  608.     MUIV_Listtree_GetNr_TreeNode_Active:
  609.       All counts are related on the active node.
  610.     
  611.     Special flags:
  612.     
  613.     MUIV_Listtree_GetNr_Flags_CountAll
  614.       Returns the number of all entries.
  615.     
  616.     MUIV_Listtree_GetNr_Flags_CountLevel
  617.       Returns the number of the entries of the list the specified node is
  618.       in.
  619.     
  620.     MUIV_Listtree_GetNr_Flags_CountList
  621.       Returns the number of the entries of the list of the specified node.
  622.     
  623.     MUIV_Listtree_GetNr_Flags_ListEmpty
  624.       Returns if the list of the specified node is empty.
  625.     
  626.  
  627.    BUGS
  628.     Not implemented yet:
  629.     MUIV_Listtree_GetNr_TreeNode_Active
  630.     MUIV_Listtree_GetNr_Flags_CountAll
  631.     MUIV_Listtree_GetNr_Flags_CountLevel
  632.     MUIV_Listtree_GetNr_Flags_CountList
  633.  
  634.    SEE ALSO
  635.     MUIM_Listtree_GetEntry
  636.  
  637. Listtree.mcc/MUIM_Listtree_Insert
  638.  
  639.    NAME
  640.     MUIM_Listtree_Insert
  641.  
  642.    SYNOPSIS
  643.     struct MUIS_Listtree_TreeNode *Node = DoMethod(obj, MUIM_Listtree_Insert,
  644.       char *Name, APTR User, APTR ListNode, APTR PrevNode, ULONG Flags);
  645.  
  646.    FUNCTION
  647.     Inserts an entry at the position, which is defined with ListNode and
  648.     PrevNode. Name contains the name of the entry as string, it is
  649.     buffered. The User entry can be used as you like.
  650.  
  651.    INPUTS
  652.     ListNode:
  653.         Specify the node which list is used to insert the entry.
  654.     
  655.         Special values:
  656.     
  657.         MUIV_Listtree_Insert_ListNode_Root:
  658.           The root list.
  659.     
  660.         MUIV_Listtree_Insert_ListNode_Active:
  661.           The list of the active node. (n/a)
  662.     
  663.     PrevNode:
  664.         The node which is the predecessor of the node to insert.
  665.     
  666.         Special values:
  667.     
  668.         MUIV_Listtree_Insert_PrevNode_Head:
  669.           It will be inserted at the head of the list.
  670.     
  671.         MUIV_Listtree_Insert_PrevNode_Tail:
  672.           It will be inserted at the tail of the list.
  673.     
  674.         MUIV_Listtree_Insert_PrevNode_Active:
  675.           After the active node it will be inserted.
  676.     
  677.         MUIV_Listtree_Insert_PrevNode_Sorted:
  678.           The node is inserted using the sort hook.
  679.     
  680.     Flags:
  681.         MUIV_Listtree_Insert_Flags_Active:
  682.           The inserted entry will be set active, this means the cursor
  683.           is moved on it.
  684.     
  685.         MUIV_Listtree_Insert_Flags_NextNode:
  686.           'PrevNode' is the successor, not the predecessor.
  687.     
  688.         The other ones specify the data in 'PrevNode'. Normally this is a
  689.         pointer to a tree node, but the flags can change this into an ULONG.
  690.     
  691.         MUIV_Listtree_Insert_Flags_Nr:
  692.           Position (ULONG number) of the node in the list of 'ListNode'.
  693.     
  694.         MUIV_Listtree_Insert_Flags_Visible:
  695.           The position is counted on visible entries only.
  696.  
  697.    BUGS
  698.     Not implemented yet:
  699.       MUIV_Listtree_Insert_ListNode_Active
  700.       MUIV_Listtree_Insert_Flags_Nr
  701.       MUIV_Listtree_Insert_Flags_Visible
  702.       MUIV_Listtree_Insert_Flags_Active
  703.  
  704.    SEE ALSO
  705.     MUIA_Listtree_SortHook
  706.  
  707. Listtree.mcc/MUIM_Listtree_Move
  708.  
  709.    NAME
  710.     MUIM_Listtree_Move
  711.  
  712.    SYNOPSIS
  713.     DoMethod(obj, MUIM_Listtree_Move,
  714.       APTR OldListNode, APTR OldTreeNode, APTR NewListNode, APTR NewTreeNode,
  715.       ULONG Flags);
  716.  
  717.    FUNCTION
  718.     Move an entry to the position after a defined node.
  719.  
  720.    INPUTS
  721.     OldListNode:
  722.         Specify the node which list is used to find the entry. The search is
  723.         started at the head of the list.
  724.     
  725.         Special values:
  726.     
  727.         MUIV_Listtree_Move_OldListNode_Root:
  728.           The root list.
  729.     
  730.         MUIV_Listtree_Move_OldListNode_Active:
  731.           The list of the active node.
  732.     
  733.     OldTreeNode:
  734.         Specify the node which should be moved.
  735.     
  736.         Special values:
  737.     
  738.         MUIV_Listtree_Move_OldTreeNode_Head
  739.           The head of the list, defined in 'OldListNode', is moved.
  740.     
  741.         MUIV_Listtree_Move_OldTreeNode_Tail:
  742.           The tail of the list is moved.
  743.     
  744.         MUIV_Listtree_Move_OldTreeNode_Active:
  745.           The active node is moved.
  746.     
  747.     NewListNode:
  748.         Specify the node which list is used to find the entry. The search is
  749.         started at the head of the list.
  750.     
  751.         Special values:
  752.     
  753.         MUIV_Listtree_Move_NewListNode_Root:
  754.           The root list.
  755.     
  756.         MUIV_Listtree_Move_NewListNode_Active:
  757.           The list of the active node.
  758.     
  759.     NewTreeNode:
  760.         This node is the predecessor of the entry which is inserted.
  761.     
  762.         Special values:
  763.     
  764.         MUIV_Listtree_Move_NewTreeNode_Head
  765.           The node is moved to the head of the list defined in
  766.           'NewListNode'.
  767.     
  768.         MUIV_Listtree_Move_NewTreeNode_Tail:
  769.           The node is moved to the tail of the list.
  770.     
  771.         MUIV_Listtree_Move_NewTreeNode_Active:
  772.           The node is moved after the active node.
  773.     
  774.         MUIV_Listtree_Move_NewTreeNode_Sorted:
  775.           The node is moved to the list using the sort hook.
  776.     
  777.     Flags:
  778.         Specify the data in 'OldTreeNode' and 'NewTreeNode'. Normally this
  779.         is a pointer to a tree node, but the flags can change this into an
  780.         ULONG.
  781.     
  782.         MUIV_Listtree_Move_Flags_Nr:
  783.           Position (ULONG number) of the nodes in the list.
  784.     
  785.         MUIV_Listtree_Move_Flags_Visible:
  786.           The position is counted on visible entries only.
  787.  
  788.    BUGS
  789.     Not implemented yet:
  790.       MUIV_Listtree_Move_Flags_Nr
  791.       MUIV_Listtree_Move_Flags_Visible
  792.  
  793.    SEE ALSO
  794.     MUIM_Listtree_Insert, MUIM_Listtree_Remove, MUIM_Listtree_Exchange
  795.  
  796. Listtree.mcc/MUIM_Listtree_Open
  797.  
  798.    NAME
  799.     MUIM_Listtree_Open
  800.  
  801.    SYNOPSIS
  802.     DoMethod(obj, MUIM_Listtree_Open,
  803.       APTR ListNode, APTR TreeNode, ULONG Flags);
  804.  
  805.    FUNCTION
  806.     Opens a node in the listtree. To open a child, which isn't displayed,
  807.     use 'MUIV_Listtree_Open_ListNode_Parent' to open all its parents, too.
  808.     
  809.     Only nodes can be opened.
  810.  
  811.    INPUTS
  812.     ListNode:
  813.         Specify the node which list is used to open the node.
  814.     
  815.         Special values:
  816.     
  817.         MUIV_Listtree_Open_ListNode_Root:
  818.           The root list.
  819.     
  820.         MUIV_Listtree_Open_ListNode_Parent:
  821.           Flag to open all the parents of the node, too.
  822.     
  823.         MUIV_Listtree_Open_ListNode_Active:
  824.           The list of the active node.
  825.     
  826.     TreeNode:
  827.         The node to open.
  828.     
  829.         Special values:
  830.     
  831.         MUIV_Listtree_Open_TreeNode_Head:
  832.           Opens the head node of the list.
  833.     
  834.         MUIV_Listtree_Open_TreeNode_Tail:
  835.           Opens the tail node of the list.
  836.     
  837.         MUIV_Listtree_Open_TreeNode_Active:
  838.           The active node will be opened.
  839.     
  840.         MUIV_Listtree_Open_TreeNode_All:
  841.           All the nodes of the list are opened.
  842.     
  843.     Flags:
  844.         The data in 'TreeNode' is normally a pointer to a tree node, but
  845.         the flags can change this into an ULONG.
  846.     
  847.         MUIV_Listtree_Open_Flags_Nr:
  848.           Position (ULONG number) of the node in the list of 'ListNode'.
  849.     
  850.         MUIV_Listtree_Open_Flags_Visible:
  851.           The position is counted on visible entries only.
  852.  
  853.    BUGS
  854.     Not implemented yet:
  855.       MUIV_Listtree_Open_Flags_Nr
  856.       MUIV_Listtree_Open_Flags_Visible
  857.  
  858.    SEE ALSO
  859.     MUIA_Listtree_Close
  860.  
  861. Listtree.mcc/MUIM_Listtree_Remove
  862.  
  863.    NAME
  864.     MUIM_Listtree_Remove
  865.  
  866.    SYNOPSIS
  867.     DoMethod(obj, MUIM_Listtree_Remove,
  868.       APTR ListNode, APTR TreeNode, ULONG Flags);
  869.  
  870.    FUNCTION
  871.     Removes a node or nodes from a listtree.
  872.     When the active entry is removed, the following entry will become
  873.     active.
  874.  
  875.    INPUTS
  876.     ListNode:
  877.         Specify the node which list is used to find the entry. The search is
  878.         started at the begin of this list.
  879.     
  880.         Special values:
  881.     
  882.         MUIV_Listtree_Remove_ListNode_Root:
  883.           The root list.
  884.     
  885.         MUIV_Listtree_Remove_ListNode_Active:
  886.           The list of the active node. (n/a)
  887.     
  888.     TreeNode:
  889.         The node which is removed. If there are children of the node, they
  890.         are also removed.
  891.     
  892.         Special values:
  893.     
  894.         MUIV_Listtree_Remove_TreeNode_Head
  895.           The head of the list, defined in 'ListNode', is removed.
  896.     
  897.         MUIV_Listtree_Remove_TreeNode_Tail:
  898.           Removes the tail of the list.
  899.     
  900.         MUIV_Listtree_Remove_TreeNode_Active:
  901.           Removes the active node.
  902.     
  903.         MUIV_Listtree_Remove_TreeNode_All:
  904.           All nodes of the list, which is specified in 'ListNode', are
  905.           removed. Other nodes of parent lists are not affected.
  906.     
  907.     Flags:
  908.         Specifies the data in 'TreeNode'. Normally this is a pointer to a
  909.         treenode, but the flags can change this into a ULONG.
  910.     
  911.         MUIV_Listtree_Remove_Flags_Nr:
  912.           Position (ULONG number) of the node in the list of 'ListNode'.
  913.     
  914.         MUIV_Listtree_Remove_Flags_Visible:
  915.           The position is counted on visible entries only.
  916.  
  917.    BUGS
  918.     Not implemented yet:
  919.       MUIV_Listtree_Remove_ListNode_Active
  920.       MUIV_Listtree_Remove_Flags_Nr
  921.       MUIV_Listtree_Remove_Flags_Visible
  922.  
  923.    EXAMPLE
  924.     /* if delete is pressed, remove the active entry */
  925.     DoMethod(bt_delete, MUIM_Notify, MUIA_Pressed, FALSE,
  926.         lt_sample, 4,
  927.         MUIM_Listtree_Remove, NULL, MUIV_Listtree_Remove_TreeNode_Active, 0);
  928.  
  929.    SEE ALSO
  930.     MUIM_Listtree_Insert, MUIA_Listtree_DestructHook,
  931.     MUIM_List_Active
  932.  
  933. Listtree.mcc/MUIM_Listtree_Rename
  934.  
  935.    NAME
  936.     MUIM_Listtree_Rename
  937.  
  938.    SYNOPSIS
  939.     APTR TreeNode = DoMethod(obj, MUIM_Listtree_Rename,
  940.       APTR TreeNode, char *NewName, ULONG Flags);
  941.  
  942.    FUNCTION
  943.     Rename the name of specified node.
  944.     
  945.     If you want to rename the tn_User field, the construct and destruct
  946.     hook are used, check them! If there are not these hook the pointer is
  947.     only copied.
  948.  
  949.    INPUTS
  950.     TreeNode:
  951.         Define the node which should be renamed.
  952.     
  953.         Special values:
  954.     
  955.         MUIV_Listtree_Rename_TreeNode_Active:
  956.           The active tree node is used.
  957.     
  958.     NewName:
  959.         The new name or pointer.
  960.     
  961.     Flags:
  962.         MUIV_Listtree_Rename_Flags_User
  963.           The tn_User field is renamed.
  964.         MUIV_Listtree_Rename_Flags_NoRefresh
  965.           The entry will not be refreshed.
  966.  
  967.    SEE ALSO
  968.     MUIA_Listtree_ConstructHook, MUIA_Listtree_DestructHook
  969.  
  970. Listtree.mcc/MUIM_Listtree_SetDropMark
  971.  
  972.    NAME
  973.     MUIM_Listtree_SetDropMark
  974.  
  975.    SPECIAL VALUES
  976.     MUIA_Listtree_SetDropMark_Values_None
  977.     MUIA_Listtree_SetDropMark_Values_Above
  978.     MUIA_Listtree_SetDropMark_Values_Below
  979.     MUIA_Listtree_SetDropMark_Values_Onto
  980.     MUIA_Listtree_SetDropMark_Values_Sorted
  981.  
  982.  
  983.    SEE ALSO
  984.     MUIA_Listtree_TestPos
  985.  
  986. Listtree.mcc/MUIM_Listtree_Sort
  987.  
  988.    NAME
  989.     MUIM_Listtree_Sort
  990.  
  991.    SYNOPSIS
  992.     DoMethod(obj, MUIM_Listtree_Sprt,
  993.       APTR ListNode, ULONG Flags);
  994.  
  995.    SEE ALSO
  996.     MUIA_Listtree_SortHook
  997.  
  998. Listtree.mcc/MUIM_Listtree_TestPos
  999.  
  1000.    NAME
  1001.     MUIM_Listtree_TestPos
  1002.  
  1003.    SYNOPSIS
  1004.     DoMethod(obj, MUIM_Listtree_TestPos,
  1005.       LONG X, LONG Y, struct MUIS_Listtree_TestPos_Result *Result);
  1006.  
  1007.    FUNCTION
  1008.     Asks the listtree which entry is under the coordinates. It is NULL if
  1009.     the entry isn't valid.
  1010.     
  1011.     The flags contains detailed information about the position at the
  1012.     entry:
  1013.     
  1014.       TestPos_Result_Flags_None
  1015.       TestPos_Result_Flags_Above
  1016.       TestPos_Result_Flags_Below
  1017.       TestPos_Result_Flags_Onto
  1018.       TestPos_Result_Flags_Sorted
  1019.     
  1020.     This is useful for Drag&Drop routines.
  1021.  
  1022.    INPUTS
  1023.     X:
  1024.         X position.
  1025.     
  1026.     Y:
  1027.         Y position.
  1028.     
  1029.     Result:
  1030.         Pointer to a MUIS_Listtree_TestPos_Result struct.
  1031.  
  1032.    RESULTS
  1033.     TreeNode:
  1034.         Entry under the specified position.
  1035.     
  1036.     Flags:
  1037.         Position on the entry:
  1038.  
  1039.    SEE ALSO
  1040.     MUIM_List_TestPos, MUIM_DragReport, MUIM_DragDrop
  1041.  
  1042. PrMake.rexx 0.10 (16.2.1996) Copyright 1995 kmel, Klaus Melchior
  1043.